home *** CD-ROM | disk | FTP | other *** search
/ Kellogg's Amérique / Kellogg's Amérique / speed.swf / scripts / fl / managers / FocusManager.as next >
Text File  |  2020-08-04  |  26KB  |  818 lines
  1. package fl.managers
  2. {
  3.    import fl.controls.Button;
  4.    import fl.core.UIComponent;
  5.    import flash.display.DisplayObject;
  6.    import flash.display.DisplayObjectContainer;
  7.    import flash.display.InteractiveObject;
  8.    import flash.display.SimpleButton;
  9.    import flash.display.Stage;
  10.    import flash.events.Event;
  11.    import flash.events.FocusEvent;
  12.    import flash.events.KeyboardEvent;
  13.    import flash.events.MouseEvent;
  14.    import flash.text.TextField;
  15.    import flash.text.TextFieldType;
  16.    import flash.ui.Keyboard;
  17.    import flash.utils.Dictionary;
  18.    
  19.    public class FocusManager implements IFocusManager
  20.    {
  21.        
  22.       
  23.       private var focusableObjects:Dictionary;
  24.       
  25.       private var _showFocusIndicator:Boolean = true;
  26.       
  27.       private var defButton:Button;
  28.       
  29.       private var focusableCandidates:Array;
  30.       
  31.       private var _form:DisplayObjectContainer;
  32.       
  33.       private var _defaultButtonEnabled:Boolean = true;
  34.       
  35.       private var activated:Boolean = false;
  36.       
  37.       private var _defaultButton:Button;
  38.       
  39.       private var calculateCandidates:Boolean = true;
  40.       
  41.       private var lastFocus:InteractiveObject;
  42.       
  43.       private var lastAction:String;
  44.       
  45.       public function FocusManager(param1:DisplayObjectContainer)
  46.       {
  47.          activated = false;
  48.          calculateCandidates = true;
  49.          _showFocusIndicator = true;
  50.          _defaultButtonEnabled = true;
  51.          super();
  52.          focusableObjects = new Dictionary(true);
  53.          if(param1 != null)
  54.          {
  55.             _form = param1;
  56.             addFocusables(DisplayObject(param1));
  57.             param1.addEventListener(Event.ADDED,addedHandler);
  58.             param1.addEventListener(Event.REMOVED,removedHandler);
  59.             activate();
  60.          }
  61.       }
  62.       
  63.       public function get showFocusIndicator() : Boolean
  64.       {
  65.          return _showFocusIndicator;
  66.       }
  67.       
  68.       private function getIndexOfNextObject(param1:int, param2:Boolean, param3:Boolean, param4:String) : int
  69.       {
  70.          var _loc5_:int = 0;
  71.          var _loc6_:int = 0;
  72.          var _loc7_:DisplayObject = null;
  73.          var _loc8_:IFocusManagerGroup = null;
  74.          var _loc9_:int = 0;
  75.          var _loc10_:DisplayObject = null;
  76.          var _loc11_:IFocusManagerGroup = null;
  77.          _loc5_ = focusableCandidates.length;
  78.          _loc6_ = param1;
  79.          while(true)
  80.          {
  81.             if(param2)
  82.             {
  83.                param1--;
  84.             }
  85.             else
  86.             {
  87.                param1++;
  88.             }
  89.             if(param3)
  90.             {
  91.                if(param2 && param1 < 0)
  92.                {
  93.                   break;
  94.                }
  95.                if(!param2 && param1 == _loc5_)
  96.                {
  97.                   break;
  98.                }
  99.             }
  100.             else
  101.             {
  102.                param1 = (param1 + _loc5_) % _loc5_;
  103.                if(_loc6_ == param1)
  104.                {
  105.                   break;
  106.                }
  107.             }
  108.             if(isValidFocusCandidate(focusableCandidates[param1],param4))
  109.             {
  110.                if((_loc7_ = DisplayObject(findFocusManagerComponent(focusableCandidates[param1]))) is IFocusManagerGroup)
  111.                {
  112.                   _loc8_ = IFocusManagerGroup(_loc7_);
  113.                   _loc9_ = 0;
  114.                   while(_loc9_ < focusableCandidates.length)
  115.                   {
  116.                      if((_loc10_ = focusableCandidates[_loc9_]) is IFocusManagerGroup)
  117.                      {
  118.                         if((_loc11_ = IFocusManagerGroup(_loc10_)).groupName == _loc8_.groupName && _loc11_.selected)
  119.                         {
  120.                            param1 = _loc9_;
  121.                            break;
  122.                         }
  123.                      }
  124.                      _loc9_++;
  125.                   }
  126.                }
  127.                return param1;
  128.             }
  129.          }
  130.          return param1;
  131.       }
  132.       
  133.       public function set form(param1:DisplayObjectContainer) : void
  134.       {
  135.          _form = param1;
  136.       }
  137.       
  138.       private function addFocusables(param1:DisplayObject, param2:Boolean = false) : void
  139.       {
  140.          var focusable:IFocusManagerComponent = null;
  141.          var io:InteractiveObject = null;
  142.          var doc:DisplayObjectContainer = null;
  143.          var i:int = 0;
  144.          var child:DisplayObject = null;
  145.          var o:DisplayObject = param1;
  146.          var skipTopLevel:Boolean = param2;
  147.          if(!skipTopLevel)
  148.          {
  149.             if(o is IFocusManagerComponent)
  150.             {
  151.                focusable = IFocusManagerComponent(o);
  152.                if(focusable.focusEnabled)
  153.                {
  154.                   if(focusable.tabEnabled && isTabVisible(o))
  155.                   {
  156.                      focusableObjects[o] = true;
  157.                      calculateCandidates = true;
  158.                   }
  159.                   o.addEventListener(Event.TAB_ENABLED_CHANGE,tabEnabledChangeHandler);
  160.                   o.addEventListener(Event.TAB_INDEX_CHANGE,tabIndexChangeHandler);
  161.                }
  162.             }
  163.             else if(o is InteractiveObject)
  164.             {
  165.                io = o as InteractiveObject;
  166.                if(io && io.tabEnabled && findFocusManagerComponent(io) == io)
  167.                {
  168.                   focusableObjects[io] = true;
  169.                   calculateCandidates = true;
  170.                }
  171.                io.addEventListener(Event.TAB_ENABLED_CHANGE,tabEnabledChangeHandler);
  172.                io.addEventListener(Event.TAB_INDEX_CHANGE,tabIndexChangeHandler);
  173.             }
  174.          }
  175.          if(o is DisplayObjectContainer)
  176.          {
  177.             doc = DisplayObjectContainer(o);
  178.             o.addEventListener(Event.TAB_CHILDREN_CHANGE,tabChildrenChangeHandler);
  179.             if(doc is Stage || doc.parent is Stage || doc.tabChildren)
  180.             {
  181.                i = 0;
  182.                for(; i < doc.numChildren; i++)
  183.                {
  184.                   try
  185.                   {
  186.                      child = doc.getChildAt(i);
  187.                      if(child != null)
  188.                      {
  189.                         addFocusables(doc.getChildAt(i));
  190.                      }
  191.                   }
  192.                   catch(error:SecurityError)
  193.                   {
  194.                      continue;
  195.                   }
  196.                }
  197.             }
  198.          }
  199.       }
  200.       
  201.       private function getChildIndex(param1:DisplayObjectContainer, param2:DisplayObject) : int
  202.       {
  203.          return param1.getChildIndex(param2);
  204.       }
  205.       
  206.       private function mouseFocusChangeHandler(param1:FocusEvent) : void
  207.       {
  208.          if(param1.relatedObject is TextField)
  209.          {
  210.             return;
  211.          }
  212.          param1.preventDefault();
  213.       }
  214.       
  215.       private function focusOutHandler(param1:FocusEvent) : void
  216.       {
  217.          var _loc2_:InteractiveObject = null;
  218.          _loc2_ = param1.target as InteractiveObject;
  219.       }
  220.       
  221.       private function isValidFocusCandidate(param1:DisplayObject, param2:String) : Boolean
  222.       {
  223.          var _loc3_:IFocusManagerGroup = null;
  224.          if(!isEnabledAndVisible(param1))
  225.          {
  226.             return false;
  227.          }
  228.          if(param1 is IFocusManagerGroup)
  229.          {
  230.             _loc3_ = IFocusManagerGroup(param1);
  231.             if(param2 == _loc3_.groupName)
  232.             {
  233.                return false;
  234.             }
  235.          }
  236.          return true;
  237.       }
  238.       
  239.       public function findFocusManagerComponent(param1:InteractiveObject) : InteractiveObject
  240.       {
  241.          var _loc2_:InteractiveObject = null;
  242.          _loc2_ = param1;
  243.          while(param1)
  244.          {
  245.             if(param1 is IFocusManagerComponent && IFocusManagerComponent(param1).focusEnabled)
  246.             {
  247.                return param1;
  248.             }
  249.             param1 = param1.parent;
  250.          }
  251.          return _loc2_;
  252.       }
  253.       
  254.       private function sortFocusableObjectsTabIndex() : void
  255.       {
  256.          var _loc1_:* = null;
  257.          var _loc2_:InteractiveObject = null;
  258.          focusableCandidates = [];
  259.          for(_loc1_ in focusableObjects)
  260.          {
  261.             _loc2_ = InteractiveObject(_loc1_);
  262.             if(_loc2_.tabIndex && !isNaN(Number(_loc2_.tabIndex)))
  263.             {
  264.                focusableCandidates.push(_loc2_);
  265.             }
  266.          }
  267.          focusableCandidates.sort(sortByTabIndex);
  268.       }
  269.       
  270.       private function removeFocusables(param1:DisplayObject) : void
  271.       {
  272.          var _loc2_:* = null;
  273.          var _loc3_:DisplayObject = null;
  274.          if(param1 is DisplayObjectContainer)
  275.          {
  276.             param1.removeEventListener(Event.TAB_CHILDREN_CHANGE,tabChildrenChangeHandler);
  277.             param1.removeEventListener(Event.TAB_INDEX_CHANGE,tabIndexChangeHandler);
  278.             for(_loc2_ in focusableObjects)
  279.             {
  280.                _loc3_ = DisplayObject(_loc2_);
  281.                if(DisplayObjectContainer(param1).contains(_loc3_))
  282.                {
  283.                   if(_loc3_ == lastFocus)
  284.                   {
  285.                      lastFocus = null;
  286.                   }
  287.                   _loc3_.removeEventListener(Event.TAB_ENABLED_CHANGE,tabEnabledChangeHandler);
  288.                   delete focusableObjects[_loc2_];
  289.                   calculateCandidates = true;
  290.                }
  291.             }
  292.          }
  293.       }
  294.       
  295.       private function addedHandler(param1:Event) : void
  296.       {
  297.          var _loc2_:DisplayObject = null;
  298.          _loc2_ = DisplayObject(param1.target);
  299.          if(_loc2_.stage)
  300.          {
  301.             addFocusables(DisplayObject(param1.target));
  302.          }
  303.       }
  304.       
  305.       private function getTopLevelFocusTarget(param1:InteractiveObject) : InteractiveObject
  306.       {
  307.          while(param1 != InteractiveObject(form))
  308.          {
  309.             if(param1 is IFocusManagerComponent && IFocusManagerComponent(param1).focusEnabled && IFocusManagerComponent(param1).mouseFocusEnabled && UIComponent(param1).enabled)
  310.             {
  311.                return param1;
  312.             }
  313.             param1 = param1.parent;
  314.             if(param1 == null)
  315.             {
  316.                break;
  317.             }
  318.          }
  319.          return null;
  320.       }
  321.       
  322.       private function tabChildrenChangeHandler(param1:Event) : void
  323.       {
  324.          var _loc2_:DisplayObjectContainer = null;
  325.          if(param1.target != param1.currentTarget)
  326.          {
  327.             return;
  328.          }
  329.          calculateCandidates = true;
  330.          _loc2_ = DisplayObjectContainer(param1.target);
  331.          if(_loc2_.tabChildren)
  332.          {
  333.             addFocusables(_loc2_,true);
  334.          }
  335.          else
  336.          {
  337.             removeFocusables(_loc2_);
  338.          }
  339.       }
  340.       
  341.       public function sendDefaultButtonEvent() : void
  342.       {
  343.          defButton.dispatchEvent(new MouseEvent(MouseEvent.CLICK));
  344.       }
  345.       
  346.       public function getFocus() : InteractiveObject
  347.       {
  348.          var _loc1_:InteractiveObject = null;
  349.          _loc1_ = form.stage.focus;
  350.          return findFocusManagerComponent(_loc1_);
  351.       }
  352.       
  353.       private function isEnabledAndVisible(param1:DisplayObject) : Boolean
  354.       {
  355.          var _loc2_:DisplayObjectContainer = null;
  356.          var _loc3_:TextField = null;
  357.          var _loc4_:SimpleButton = null;
  358.          _loc2_ = DisplayObject(form).parent;
  359.          while(param1 != _loc2_)
  360.          {
  361.             if(param1 is UIComponent)
  362.             {
  363.                if(!UIComponent(param1).enabled)
  364.                {
  365.                   return false;
  366.                }
  367.             }
  368.             else if(param1 is TextField)
  369.             {
  370.                _loc3_ = TextField(param1);
  371.                if(_loc3_.type == TextFieldType.DYNAMIC || !_loc3_.selectable)
  372.                {
  373.                   return false;
  374.                }
  375.             }
  376.             else if(param1 is SimpleButton)
  377.             {
  378.                if(!(_loc4_ = SimpleButton(param1)).enabled)
  379.                {
  380.                   return false;
  381.                }
  382.             }
  383.             if(!param1.visible)
  384.             {
  385.                return false;
  386.             }
  387.             param1 = param1.parent;
  388.          }
  389.          return true;
  390.       }
  391.       
  392.       public function set defaultButton(param1:Button) : void
  393.       {
  394.          var _loc2_:Button = null;
  395.          _loc2_ = !!param1 ? Button(param1) : null;
  396.          if(_loc2_ != _defaultButton)
  397.          {
  398.             if(_defaultButton)
  399.             {
  400.                _defaultButton.emphasized = false;
  401.             }
  402.             if(defButton)
  403.             {
  404.                defButton.emphasized = false;
  405.             }
  406.             _defaultButton = _loc2_;
  407.             defButton = _loc2_;
  408.             if(_loc2_)
  409.             {
  410.                _loc2_.emphasized = true;
  411.             }
  412.          }
  413.       }
  414.       
  415.       private function deactivateHandler(param1:Event) : void
  416.       {
  417.          var _loc2_:InteractiveObject = null;
  418.          _loc2_ = InteractiveObject(param1.target);
  419.       }
  420.       
  421.       public function setFocus(param1:InteractiveObject) : void
  422.       {
  423.          if(param1 is IFocusManagerComponent)
  424.          {
  425.             IFocusManagerComponent(param1).setFocus();
  426.          }
  427.          else
  428.          {
  429.             form.stage.focus = param1;
  430.          }
  431.       }
  432.       
  433.       private function setFocusToNextObject(param1:FocusEvent) : void
  434.       {
  435.          var _loc2_:InteractiveObject = null;
  436.          if(!hasFocusableObjects())
  437.          {
  438.             return;
  439.          }
  440.          _loc2_ = getNextFocusManagerComponent(param1.shiftKey);
  441.          if(_loc2_)
  442.          {
  443.             setFocus(_loc2_);
  444.          }
  445.       }
  446.       
  447.       private function hasFocusableObjects() : Boolean
  448.       {
  449.          var _loc1_:* = null;
  450.          var _loc2_:int = 0;
  451.          var _loc3_:* = focusableObjects;
  452.          for(_loc1_ in _loc3_)
  453.          {
  454.             return true;
  455.          }
  456.          return false;
  457.       }
  458.       
  459.       private function tabIndexChangeHandler(param1:Event) : void
  460.       {
  461.          calculateCandidates = true;
  462.       }
  463.       
  464.       private function sortFocusableObjects() : void
  465.       {
  466.          var _loc1_:* = null;
  467.          var _loc2_:InteractiveObject = null;
  468.          focusableCandidates = [];
  469.          for(_loc1_ in focusableObjects)
  470.          {
  471.             _loc2_ = InteractiveObject(_loc1_);
  472.             if(_loc2_.tabIndex && !isNaN(Number(_loc2_.tabIndex)) && _loc2_.tabIndex > 0)
  473.             {
  474.                sortFocusableObjectsTabIndex();
  475.                return;
  476.             }
  477.             focusableCandidates.push(_loc2_);
  478.          }
  479.          focusableCandidates.sort(sortByDepth);
  480.       }
  481.       
  482.       private function keyFocusChangeHandler(param1:FocusEvent) : void
  483.       {
  484.          showFocusIndicator = true;
  485.          if((param1.keyCode == Keyboard.TAB || param1.keyCode == 0) && !param1.isDefaultPrevented())
  486.          {
  487.             setFocusToNextObject(param1);
  488.             param1.preventDefault();
  489.          }
  490.       }
  491.       
  492.       private function getIndexOfFocusedObject(param1:DisplayObject) : int
  493.       {
  494.          var _loc2_:int = 0;
  495.          var _loc3_:int = 0;
  496.          _loc2_ = focusableCandidates.length;
  497.          _loc3_ = 0;
  498.          _loc3_ = 0;
  499.          while(_loc3_ < _loc2_)
  500.          {
  501.             if(focusableCandidates[_loc3_] == param1)
  502.             {
  503.                return _loc3_;
  504.             }
  505.             _loc3_++;
  506.          }
  507.          return -1;
  508.       }
  509.       
  510.       public function hideFocus() : void
  511.       {
  512.       }
  513.       
  514.       private function removedHandler(param1:Event) : void
  515.       {
  516.          var _loc2_:int = 0;
  517.          var _loc3_:DisplayObject = null;
  518.          var _loc4_:InteractiveObject = null;
  519.          _loc3_ = DisplayObject(param1.target);
  520.          if(_loc3_ is IFocusManagerComponent && focusableObjects[_loc3_] == true)
  521.          {
  522.             if(_loc3_ == lastFocus)
  523.             {
  524.                IFocusManagerComponent(lastFocus).drawFocus(false);
  525.                lastFocus = null;
  526.             }
  527.             _loc3_.removeEventListener(Event.TAB_ENABLED_CHANGE,tabEnabledChangeHandler);
  528.             delete focusableObjects[_loc3_];
  529.             calculateCandidates = true;
  530.          }
  531.          else if(_loc3_ is InteractiveObject && focusableObjects[_loc3_] == true)
  532.          {
  533.             if(_loc4_ = _loc3_ as InteractiveObject)
  534.             {
  535.                if(_loc4_ == lastFocus)
  536.                {
  537.                   lastFocus = null;
  538.                }
  539.                delete focusableObjects[_loc4_];
  540.                calculateCandidates = true;
  541.             }
  542.             _loc3_.addEventListener(Event.TAB_ENABLED_CHANGE,tabEnabledChangeHandler);
  543.          }
  544.          removeFocusables(_loc3_);
  545.       }
  546.       
  547.       private function sortByDepth(param1:InteractiveObject, param2:InteractiveObject) : Number
  548.       {
  549.          var _loc3_:String = null;
  550.          var _loc4_:String = null;
  551.          var _loc5_:int = 0;
  552.          var _loc6_:String = null;
  553.          var _loc7_:String = null;
  554.          var _loc8_:String = null;
  555.          var _loc9_:DisplayObject = null;
  556.          var _loc10_:DisplayObject = null;
  557.          _loc3_ = "";
  558.          _loc4_ = "";
  559.          _loc8_ = "0000";
  560.          _loc9_ = DisplayObject(param1);
  561.          _loc10_ = DisplayObject(param2);
  562.          while(_loc9_ != DisplayObject(form) && _loc9_.parent)
  563.          {
  564.             if((_loc6_ = (_loc5_ = getChildIndex(_loc9_.parent,_loc9_)).toString(16)).length < 4)
  565.             {
  566.                _loc7_ = _loc8_.substring(0,4 - _loc6_.length) + _loc6_;
  567.             }
  568.             _loc3_ = _loc7_ + _loc3_;
  569.             _loc9_ = _loc9_.parent;
  570.          }
  571.          while(_loc10_ != DisplayObject(form) && _loc10_.parent)
  572.          {
  573.             if((_loc6_ = (_loc5_ = getChildIndex(_loc10_.parent,_loc10_)).toString(16)).length < 4)
  574.             {
  575.                _loc7_ = _loc8_.substring(0,4 - _loc6_.length) + _loc6_;
  576.             }
  577.             _loc4_ = _loc7_ + _loc4_;
  578.             _loc10_ = _loc10_.parent;
  579.          }
  580.          return _loc3_ > _loc4_ ? Number(1) : (_loc3_ < _loc4_ ? Number(-1) : Number(0));
  581.       }
  582.       
  583.       public function get defaultButton() : Button
  584.       {
  585.          return _defaultButton;
  586.       }
  587.       
  588.       private function activateHandler(param1:Event) : void
  589.       {
  590.          var _loc2_:InteractiveObject = null;
  591.          _loc2_ = InteractiveObject(param1.target);
  592.          if(lastFocus)
  593.          {
  594.             if(lastFocus is IFocusManagerComponent)
  595.             {
  596.                IFocusManagerComponent(lastFocus).setFocus();
  597.             }
  598.             else
  599.             {
  600.                form.stage.focus = lastFocus;
  601.             }
  602.          }
  603.          lastAction = "ACTIVATE";
  604.       }
  605.       
  606.       public function showFocus() : void
  607.       {
  608.       }
  609.       
  610.       public function set defaultButtonEnabled(param1:Boolean) : void
  611.       {
  612.          _defaultButtonEnabled = param1;
  613.       }
  614.       
  615.       public function getNextFocusManagerComponent(param1:Boolean = false) : InteractiveObject
  616.       {
  617.          var _loc2_:DisplayObject = null;
  618.          var _loc3_:String = null;
  619.          var _loc4_:int = 0;
  620.          var _loc5_:Boolean = false;
  621.          var _loc6_:int = 0;
  622.          var _loc7_:int = 0;
  623.          var _loc8_:IFocusManagerGroup = null;
  624.          if(!hasFocusableObjects())
  625.          {
  626.             return null;
  627.          }
  628.          if(calculateCandidates)
  629.          {
  630.             sortFocusableObjects();
  631.             calculateCandidates = false;
  632.          }
  633.          _loc2_ = form.stage.focus;
  634.          _loc2_ = DisplayObject(findFocusManagerComponent(InteractiveObject(_loc2_)));
  635.          _loc3_ = "";
  636.          if(_loc2_ is IFocusManagerGroup)
  637.          {
  638.             _loc3_ = (_loc8_ = IFocusManagerGroup(_loc2_)).groupName;
  639.          }
  640.          _loc4_ = getIndexOfFocusedObject(_loc2_);
  641.          _loc5_ = false;
  642.          _loc6_ = _loc4_;
  643.          if(_loc4_ == -1)
  644.          {
  645.             if(param1)
  646.             {
  647.                _loc4_ = focusableCandidates.length;
  648.             }
  649.             _loc5_ = true;
  650.          }
  651.          _loc7_ = getIndexOfNextObject(_loc4_,param1,_loc5_,_loc3_);
  652.          return findFocusManagerComponent(focusableCandidates[_loc7_]);
  653.       }
  654.       
  655.       private function mouseDownHandler(param1:MouseEvent) : void
  656.       {
  657.          var _loc2_:InteractiveObject = null;
  658.          if(param1.isDefaultPrevented())
  659.          {
  660.             return;
  661.          }
  662.          _loc2_ = getTopLevelFocusTarget(InteractiveObject(param1.target));
  663.          if(!_loc2_)
  664.          {
  665.             return;
  666.          }
  667.          showFocusIndicator = false;
  668.          if((_loc2_ != lastFocus || lastAction == "ACTIVATE") && !(_loc2_ is TextField))
  669.          {
  670.             setFocus(_loc2_);
  671.          }
  672.          lastAction = "MOUSEDOWN";
  673.       }
  674.       
  675.       private function isTabVisible(param1:DisplayObject) : Boolean
  676.       {
  677.          var _loc2_:DisplayObjectContainer = null;
  678.          _loc2_ = param1.parent;
  679.          while(_loc2_ && !(_loc2_ is Stage) && !(_loc2_.parent && _loc2_.parent is Stage))
  680.          {
  681.             if(!_loc2_.tabChildren)
  682.             {
  683.                return false;
  684.             }
  685.             _loc2_ = _loc2_.parent;
  686.          }
  687.          return true;
  688.       }
  689.       
  690.       public function get nextTabIndex() : int
  691.       {
  692.          return 0;
  693.       }
  694.       
  695.       private function keyDownHandler(param1:KeyboardEvent) : void
  696.       {
  697.          if(param1.keyCode == Keyboard.TAB)
  698.          {
  699.             lastAction = "KEY";
  700.             if(calculateCandidates)
  701.             {
  702.                sortFocusableObjects();
  703.                calculateCandidates = false;
  704.             }
  705.          }
  706.          if(defaultButtonEnabled && param1.keyCode == Keyboard.ENTER && defaultButton && defButton.enabled)
  707.          {
  708.             sendDefaultButtonEvent();
  709.          }
  710.       }
  711.       
  712.       private function focusInHandler(param1:FocusEvent) : void
  713.       {
  714.          var _loc2_:InteractiveObject = null;
  715.          var _loc3_:Button = null;
  716.          _loc2_ = InteractiveObject(param1.target);
  717.          if(form.contains(_loc2_))
  718.          {
  719.             lastFocus = findFocusManagerComponent(InteractiveObject(_loc2_));
  720.             if(lastFocus is Button)
  721.             {
  722.                _loc3_ = Button(lastFocus);
  723.                if(defButton)
  724.                {
  725.                   defButton.emphasized = false;
  726.                   defButton = _loc3_;
  727.                   _loc3_.emphasized = true;
  728.                }
  729.             }
  730.             else if(defButton && defButton != _defaultButton)
  731.             {
  732.                defButton.emphasized = false;
  733.                defButton = _defaultButton;
  734.                _defaultButton.emphasized = true;
  735.             }
  736.          }
  737.       }
  738.       
  739.       private function tabEnabledChangeHandler(param1:Event) : void
  740.       {
  741.          var _loc2_:InteractiveObject = null;
  742.          var _loc3_:* = false;
  743.          calculateCandidates = true;
  744.          _loc2_ = InteractiveObject(param1.target);
  745.          _loc3_ = focusableObjects[_loc2_] == true;
  746.          if(_loc2_.tabEnabled)
  747.          {
  748.             if(!_loc3_ && isTabVisible(_loc2_))
  749.             {
  750.                if(!(_loc2_ is IFocusManagerComponent))
  751.                {
  752.                   _loc2_.focusRect = false;
  753.                }
  754.                focusableObjects[_loc2_] = true;
  755.             }
  756.          }
  757.          else if(_loc3_)
  758.          {
  759.             delete focusableObjects[_loc2_];
  760.          }
  761.       }
  762.       
  763.       public function set showFocusIndicator(param1:Boolean) : void
  764.       {
  765.          _showFocusIndicator = param1;
  766.       }
  767.       
  768.       public function get form() : DisplayObjectContainer
  769.       {
  770.          return _form;
  771.       }
  772.       
  773.       private function sortByTabIndex(param1:InteractiveObject, param2:InteractiveObject) : int
  774.       {
  775.          return param1.tabIndex > param2.tabIndex ? 1 : (param1.tabIndex < param2.tabIndex ? -1 : int(sortByDepth(param1,param2)));
  776.       }
  777.       
  778.       public function activate() : void
  779.       {
  780.          if(activated)
  781.          {
  782.             return;
  783.          }
  784.          form.stage.addEventListener(FocusEvent.MOUSE_FOCUS_CHANGE,mouseFocusChangeHandler,false,0,true);
  785.          form.stage.addEventListener(FocusEvent.KEY_FOCUS_CHANGE,keyFocusChangeHandler,false,0,true);
  786.          form.addEventListener(FocusEvent.FOCUS_IN,focusInHandler,true);
  787.          form.addEventListener(FocusEvent.FOCUS_OUT,focusOutHandler,true);
  788.          form.stage.addEventListener(Event.ACTIVATE,activateHandler,false,0,true);
  789.          form.stage.addEventListener(Event.DEACTIVATE,deactivateHandler,false,0,true);
  790.          form.addEventListener(MouseEvent.MOUSE_DOWN,mouseDownHandler);
  791.          form.addEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler,true);
  792.          activated = true;
  793.          if(lastFocus)
  794.          {
  795.             setFocus(lastFocus);
  796.          }
  797.       }
  798.       
  799.       public function deactivate() : void
  800.       {
  801.          form.stage.removeEventListener(FocusEvent.MOUSE_FOCUS_CHANGE,mouseFocusChangeHandler);
  802.          form.stage.removeEventListener(FocusEvent.KEY_FOCUS_CHANGE,keyFocusChangeHandler);
  803.          form.removeEventListener(FocusEvent.FOCUS_IN,focusInHandler,true);
  804.          form.removeEventListener(FocusEvent.FOCUS_OUT,focusOutHandler,true);
  805.          form.stage.removeEventListener(Event.ACTIVATE,activateHandler);
  806.          form.stage.removeEventListener(Event.DEACTIVATE,deactivateHandler);
  807.          form.removeEventListener(MouseEvent.MOUSE_DOWN,mouseDownHandler);
  808.          form.removeEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler,true);
  809.          activated = false;
  810.       }
  811.       
  812.       public function get defaultButtonEnabled() : Boolean
  813.       {
  814.          return _defaultButtonEnabled;
  815.       }
  816.    }
  817. }
  818.